 package com.xlm1.mindmap;

 import android.content.Context;
 import android.graphics.Rect;
 import android.util.AttributeSet;
 import android.view.FocusFinder;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.VelocityTracker;
 import android.view.View;
 import android.view.ViewConfiguration;
 import android.view.ViewGroup;
 import android.view.ViewParent;
 import android.view.animation.AnimationUtils;
 import android.widget.FrameLayout;
 import android.widget.Scroller;

 import java.util.List;

 /**
 * Reference to ScrollView and HorizontalScrollView
 */
 public class HVScrollView extends FrameLayout {
     static final int ANIMATED_SCROLL_GAP = 250;

     static final float MAX_SCROLL_FACTOR = 0.5f;


     private long mLastScroll;

     private final Rect mTempRect = new Rect();
     private Scroller mScroller;

     /**
      * Flag to indicate that we are moving focus ourselves. This is so the
      * code that watches for focus changes initiated outside this ScrollView
      * knows that it does not have to do anything.
      */
     private boolean mScrollViewMovedFocus;

     /**
      * Position of the last motion event.
      */
     private float mLastMotionY;
     private float mLastMotionX;

     /**
      * True when the layout has changed but the traversal has not come through yet.
      * Ideally the view hierarchy would keep track of this for us.
      */
     private boolean mIsLayoutDirty = true;

     /**
      * The child to give focus to in the event that a child has requested focus while the
      * layout is dirty. This prevents the scroll from being wrong if the child has not been
      * laid out before requesting focus.
      */
     private View mChildToScrollTo = null;

     /**
      * True if the user is currently dragging this ScrollView around. This is
      * not the same as 'is being flinged', which can be checked by
      * mScroller.isFinished() (flinging begins when the user lifts his finger).
      */
     private boolean mIsBeingDragged = false;

     /**
      * Determines speed during touch scrolling
      */
     private VelocityTracker mVelocityTracker;

     /**
      * When set to true, the scroll view measure its child to make it fill the currently
      * visible area.
      */
     private boolean mFillViewport;

     /**
      * Whether arrow scrolling is animated.
      */
     private boolean mSmoothScrollingEnabled = true;

     private int mTouchSlop;
     private int mMinimumVelocity;
     private int mMaximumVelocity;

     /**
      * ID of the active pointer. This is used to retain consistency during
      * drags/flings if multiple pointers are used.
      */
     private int mActivePointerId = INVALID_POINTER;

     /**
      * Sentinel value for no current active pointer.
      * Used by {@link #mActivePointerId}.
      */
     private static final int INVALID_POINTER = -1;

     private boolean mFlingEnabled = true;

     public HVScrollView(Context context) {
         this(context, null);
     }

     public HVScrollView(Context context, AttributeSet attrs) {
         super(context, attrs);
         initScrollView();
     }

     @Override
     protected float getTopFadingEdgeStrength() {
         if (getChildCount() == 0) {
             return 0.0f;
         }

         final int length = getVerticalFadingEdgeLength();
         if (getScrollY() < length) {
             return getScrollY() / (float) length;
         }

         return 1.0f;
     }

     @Override
     protected float getLeftFadingEdgeStrength() {
         if (getChildCount() == 0) {
             return 0.0f;
         }

         final int length = getHorizontalFadingEdgeLength();
         if (getScrollX() < length) {
             return getScrollX() / (float) length;
         }

         return 1.0f;
     }

     @Override
     protected float getRightFadingEdgeStrength() {
         if (getChildCount() == 0) {
             return 0.0f;
         }

         final int length = getHorizontalFadingEdgeLength();
         final int rightEdge = getWidth() - getPaddingRight();
         final int span = getChildAt(0).getRight() - getScrollX() - rightEdge;
         if (span < length) {
             return span / (float) length;
         }

         return 1.0f;
     }

     @Override
     protected float getBottomFadingEdgeStrength() {
         if (getChildCount() == 0) {
             return 0.0f;
         }

         final int length = getVerticalFadingEdgeLength();
         final int bottomEdge = getHeight() - getPaddingBottom();
         final int span = getChildAt(0).getBottom() - getScrollY() - bottomEdge;
         if (span < length) {
             return span / (float) length;
         }

         return 1.0f;
     }

     /**
      * @return The maximum amount this scroll view will scroll in response to
      *   an arrow event.
      */
      public int getMaxScrollAmountV() {
         return (int) (MAX_SCROLL_FACTOR * (getBottom() - getTop()));
     }

     public int getMaxScrollAmountH() {
         return (int) (MAX_SCROLL_FACTOR * (getRight() - getLeft()));
     }


     private void initScrollView() {
         mScroller = new Scroller(getContext());
         setFocusable(true);
         setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
         setWillNotDraw(false);
         final ViewConfiguration configuration = ViewConfiguration.get(getContext());
         mTouchSlop = configuration.getScaledTouchSlop();
         mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
         mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
     }

     @Override
     public void addView(View child) {
         if (getChildCount() > 0) {
             throw new IllegalStateException("ScrollView can host only one direct child");
         }

         super.addView(child);
     }

     @Override
     public void addView(View child, int index) {
         if (getChildCount() > 0) {
             throw new IllegalStateException("ScrollView can host only one direct child");
         }

         super.addView(child, index);
     }

     @Override
     public void addView(View child, ViewGroup.LayoutParams params) {
         if (getChildCount() > 0) {
             throw new IllegalStateException("ScrollView can host only one direct child");
         }

         super.addView(child, params);
     }

     @Override
     public void addView(View child, int index, ViewGroup.LayoutParams params) {
         if (getChildCount() > 0) {
             throw new IllegalStateException("ScrollView can host only one direct child");
         }

         super.addView(child, index, params);
     }

     /**
      * @return Returns true this ScrollView can be scrolled
      */
     private boolean canScrollV() {
         View child = getChildAt(0);
         if (child != null) {
             int childHeight = child.getHeight();
             return getHeight() < childHeight + getPaddingTop() + getPaddingBottom();
         }
         return false;
     }

     private boolean canScrollH() {
         View child = getChildAt(0);
         if (child != null) {
             int childWidth = child.getWidth();
             return getWidth() < childWidth + getPaddingLeft() + getPaddingRight() ;
         }
         return false;
     }

     /**
      * Indicates whether this ScrollView's content is stretched to fill the viewport.
      *
      * @return True if the content fills the viewport, false otherwise.
      */
     public boolean isFillViewport() {
         return mFillViewport;
     }

     /**
      * Indicates this ScrollView whether it should stretch its content height to fill
      * the viewport or not.
      *
      * @param fillViewport True to stretch the content's height to the viewport's
      *        boundaries, false otherwise.
      */
     public void setFillViewport(boolean fillViewport) {
         if (fillViewport != mFillViewport) {
             mFillViewport = fillViewport;
             requestLayout();
         }
     }

     /**
      * @return Whether arrow scrolling will animate its transition.
      */
     public boolean isSmoothScrollingEnabled() {
         return mSmoothScrollingEnabled;
     }

     /**
      * Set whether arrow scrolling will animate its transition.
      * @param smoothScrollingEnabled whether arrow scrolling will animate its transition
      */
     public void setSmoothScrollingEnabled(boolean smoothScrollingEnabled) {
         mSmoothScrollingEnabled = smoothScrollingEnabled;
     }

     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);

         if (!mFillViewport) {
             return;
         }

         final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
         final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
         if (heightMode == MeasureSpec.UNSPECIFIED && widthMode == MeasureSpec.UNSPECIFIED) {
             return;
         }

         if (getChildCount() > 0) {
             final View child = getChildAt(0);
             int height = getMeasuredHeight();
             int width = getMeasuredWidth();
             if (child.getMeasuredHeight() < height || child.getMeasuredWidth() < width) {
                 width -= getPaddingLeft();
                 width -= getPaddingRight();
                 int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);

                 height -= getPaddingTop();
                 height -= getPaddingBottom();
                 int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);

                 child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
             }
         }
     }
     @Override
     public boolean dispatchKeyEvent(KeyEvent event) {
         // Let the focused view and/or our descendants get the key first
         return super.dispatchKeyEvent(event) || executeKeyEvent(event);
     }

     /**
      * You can call this function yourself to have the scroll view perform
      * scrolling from a key event, just as if the event had been dispatched to
      * it by the view hierarchy.
      *
      * @param event The key event to execute.
      * @return Return true if the event was handled, else false.
      */
     public boolean executeKeyEvent(KeyEvent event) {
         mTempRect.setEmpty();

         boolean handled = false;

         if (event.getAction() == KeyEvent.ACTION_DOWN) {
             switch (event.getKeyCode()) {
             case KeyEvent.KEYCODE_DPAD_LEFT:
                 if(canScrollH()){
                     if (!event.isAltPressed()) {
                         handled = arrowScrollH(View.FOCUS_LEFT);
                     } else {
                         handled = fullScrollH(View.FOCUS_LEFT);
                     }
                 }
                 break;
             case KeyEvent.KEYCODE_DPAD_RIGHT:
                 if(canScrollH()){
                     if (!event.isAltPressed()) {
                         handled = arrowScrollH(View.FOCUS_RIGHT);
                     } else {
                         handled = fullScrollH(View.FOCUS_RIGHT);
                     }
                 }
                 break;
             case KeyEvent.KEYCODE_DPAD_UP:
                 if(canScrollV()){
                     if (!event.isAltPressed()) {
                         handled = arrowScrollV(View.FOCUS_UP);
                     } else {
                         handled = fullScrollV(View.FOCUS_UP);
                     }
                 }
                 break;
             case KeyEvent.KEYCODE_DPAD_DOWN:
                 if(canScrollV()){
                     if (!event.isAltPressed()) {
                         handled = arrowScrollV(View.FOCUS_DOWN);
                     } else {
                         handled = fullScrollV(View.FOCUS_DOWN);
                     }
                 }
                 break;
             }
         }
         return handled;
     }

     private boolean inChild(int x, int y) {
         if (getChildCount() > 0) {
             final int scrollX = getScrollX();
             final int scrollY = getScrollY();
             final View child = getChildAt(0);
             return !(y < child.getTop() - scrollY
                     || y >= child.getBottom() - scrollY
                     || x < child.getLeft() - scrollX
                     || x >= child.getRight() - scrollX);
         }
         return false;
     }

     @Override
     public boolean onInterceptTouchEvent(MotionEvent ev) {
         /*
          * This method JUST determines whether we want to intercept the motion.
          * If we return true, onMotionEvent will be called and we do the actual
          * scrolling there.
          */

         /*
          * Shortcut the most recurring case: the user is in the dragging
          * state and he is moving his finger.  We want to intercept this
          * motion.
          */
         final int action = ev.getAction();
         if ((action == MotionEvent.ACTION_MOVE) && (mIsBeingDragged)) {
             return true;
         }

         switch (action & MotionEvent.ACTION_MASK) {
         case MotionEvent.ACTION_MOVE: {
             /*
              * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check
              * whether the user has moved far enough from his original down touch.
              */

             /*
              * Locally do absolute value. mLastMotionY is set to the y value
              * of the down event.
              */
             final int activePointerId = mActivePointerId;
             if (activePointerId == INVALID_POINTER) {
                 // If we don't have a valid id, the touch down wasn't on content.
                 break;
             }

             final int pointerIndex = ev.findPointerIndex(activePointerId);
             final float y = ev.getY(pointerIndex);
             final int yDiff = (int) Math.abs(y - mLastMotionY);
             if (yDiff > mTouchSlop) {
                 mIsBeingDragged = true;
                 mLastMotionY = y;
             }
             final float x = ev.getX(pointerIndex);
             final int xDiff = (int) Math.abs(x - mLastMotionX);
             if (xDiff > mTouchSlop) {
                 mIsBeingDragged = true;
                 mLastMotionX = x;
             }
             break;
         }

         case MotionEvent.ACTION_DOWN: {
             final float x = ev.getX();
             final float y = ev.getY();
             if (!inChild((int)x, (int) y)) {
                 mIsBeingDragged = false;
                 break;
             }

             /*
              * Remember location of down touch.
              * ACTION_DOWN always refers to pointer index 0.
              */
             mLastMotionY = y;
             mLastMotionX = x;
             mActivePointerId = ev.getPointerId(0);

             /*
              * If being flinged and user touches the screen, initiate drag;
              * otherwise don't.  mScroller.isFinished should be false when
              * being flinged.
              */
             mIsBeingDragged = !mScroller.isFinished();
             break;
         }

         case MotionEvent.ACTION_CANCEL:
         case MotionEvent.ACTION_UP:
             /* Release the drag */
             mIsBeingDragged = false;
             mActivePointerId = INVALID_POINTER;
             break;
         case MotionEvent.ACTION_POINTER_UP:
             onSecondaryPointerUp(ev);
             break;
         }

         /*
          * The only time we want to intercept motion events is if we are in the
          * drag mode.
          */
         return mIsBeingDragged;
     }

     @Override
     public boolean onTouchEvent(MotionEvent ev) {

         if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {
             // Don't handle edge touches immediately -- they may actually belong to one of our
             // descendants.
             return false;
         }

         if (mVelocityTracker == null) {
             mVelocityTracker = VelocityTracker.obtain();
         }
         mVelocityTracker.addMovement(ev);

         final int action = ev.getAction();

         switch (action & MotionEvent.ACTION_MASK) {
         case MotionEvent.ACTION_DOWN: {
             final float x = ev.getX();
             final float y = ev.getY();
             if (!(mIsBeingDragged = inChild((int) x, (int) y))) {
                 return false;
             }

             /*
              * If being flinged and user touches, stop the fling. isFinished
              * will be false if being flinged.
              */
             if (!mScroller.isFinished()) {
                 mScroller.abortAnimation();
             }

             // Remember where the motion event started
             mLastMotionY = y;
             mLastMotionX = x;
             mActivePointerId = ev.getPointerId(0);
             break;
         }
         case MotionEvent.ACTION_MOVE:
             if (mIsBeingDragged) {
                 // Scroll to follow the motion event
                 final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
                 final float y = ev.getY(activePointerIndex);
                 final int deltaY = (int) (mLastMotionY - y);
                 mLastMotionY = y;

                 final float x = ev.getX(activePointerIndex);
                 final int deltaX = (int) (mLastMotionX - x);
                 mLastMotionX = x;

                 scrollBy(deltaX, deltaY);
             }
             break;
         case MotionEvent.ACTION_UP:
             if (mIsBeingDragged) {
                 if(mFlingEnabled){
                     final VelocityTracker velocityTracker = mVelocityTracker;
                     velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                     int initialVelocitx = (int) velocityTracker.getXVelocity();
                     int initialVelocity = (int) velocityTracker.getYVelocity();
 //                  int initialVelocitx = (int) velocityTracker.getXVelocity(mActivePointerId);
 //                  int initialVelocity = (int) velocityTracker.getYVelocity(mActivePointerId);

                     if (getChildCount() > 0) {
                         if(Math.abs(initialVelocitx) > initialVelocitx || Math.abs(initialVelocity) > mMinimumVelocity) {
                             fling(-initialVelocitx, -initialVelocity);
                         }

                     }
                 }

                 mActivePointerId = INVALID_POINTER;
                 mIsBeingDragged = false;

                 if (mVelocityTracker != null) {
                     mVelocityTracker.recycle();
                     mVelocityTracker = null;
                 }
             }
             break;
         case MotionEvent.ACTION_CANCEL:
             if (mIsBeingDragged && getChildCount() > 0) {
                 mActivePointerId = INVALID_POINTER;
                 mIsBeingDragged = false;
                 if (mVelocityTracker != null) {
                     mVelocityTracker.recycle();
                     mVelocityTracker = null;
                 }
             }
             break;
         case MotionEvent.ACTION_POINTER_UP:
             onSecondaryPointerUp(ev);
             break;
         }
         return true;
     }

     private void onSecondaryPointerUp(MotionEvent ev) {
         final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_ID_MASK) >>
         MotionEvent.ACTION_POINTER_ID_SHIFT;
         final int pointerId = ev.getPointerId(pointerIndex);
         if (pointerId == mActivePointerId) {
             // This was our active pointer going up. Choose a new
             // active pointer and adjust accordingly.
             final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
             mLastMotionX = ev.getX(newPointerIndex);
             mLastMotionY = ev.getY(newPointerIndex);
             mActivePointerId = ev.getPointerId(newPointerIndex);
             if (mVelocityTracker != null) {
                 mVelocityTracker.clear();
             }
         }
     }
     /**
      * <p>
      * Finds the next focusable component that fits in the specified bounds.
      * </p>
      *
      * @param topFocus look for a candidate is the one at the top of the bounds
      *                 if topFocus is true, or at the bottom of the bounds if topFocus is
      *                 false
      * @param top      the top offset of the bounds in which a focusable must be
      *                 found
      * @param bottom   the bottom offset of the bounds in which a focusable must
      *                 be found
      * @return the next focusable component in the bounds or null if none can
      *         be found
      */
     private View findFocusableViewInBoundsV(boolean topFocus, int top, int bottom) {

         List<View> focusables = getFocusables(View.FOCUS_FORWARD);
         View focusCandidate = null;

         /*
          * A fully contained focusable is one where its top is below the bound's
          * top, and its bottom is above the bound's bottom. A partially
          * contained focusable is one where some part of it is within the
          * bounds, but it also has some part that is not within bounds.  A fully contained
          * focusable is preferred to a partially contained focusable.
          */
         boolean foundFullyContainedFocusable = false;

         int count = focusables.size();
         for (int i = 0; i < count; i++) {
             View view = focusables.get(i);
             int viewTop = view.getTop();
             int viewBottom = view.getBottom();

             if (top < viewBottom && viewTop < bottom) {
                 /*
                  * the focusable is in the target area, it is a candidate for
                  * focusing
                  */

                 final boolean viewIsFullyContained = (top < viewTop) &&
                 (viewBottom < bottom);

                 if (focusCandidate == null) {
                     /* No candidate, take this one */
                     focusCandidate = view;
                     foundFullyContainedFocusable = viewIsFullyContained;
                 } else {
                     final boolean viewIsCloserToBoundary =
                         (topFocus && viewTop < focusCandidate.getTop()) ||
                         (!topFocus && viewBottom > focusCandidate
                                 .getBottom());

                     if (foundFullyContainedFocusable) {
                         if (viewIsFullyContained && viewIsCloserToBoundary) {
                             /*
                              * We're dealing with only fully contained views, so
                              * it has to be closer to the boundary to beat our
                              * candidate
                              */
                             focusCandidate = view;
                         }
                     } else {
                         if (viewIsFullyContained) {
                             /* Any fully contained view beats a partially contained view */
                             focusCandidate = view;
                             foundFullyContainedFocusable = true;
                         } else if (viewIsCloserToBoundary) {
                             /*
                              * Partially contained view beats another partially
                              * contained view if it's closer
                              */
                             focusCandidate = view;
                         }
                     }
                 }
             }
         }

         return focusCandidate;
     }

     private View findFocusableViewInBoundsH(boolean leftFocus, int left, int right) {

         List<View> focusables = getFocusables(View.FOCUS_FORWARD);
         View focusCandidate = null;

         /*
          * A fully contained focusable is one where its left is below the bound's
          * left, and its right is above the bound's right. A partially
          * contained focusable is one where some part of it is within the
          * bounds, but it also has some part that is not within bounds.  A fully contained
          * focusable is preferred to a partially contained focusable.
          */
         boolean foundFullyContainedFocusable = false;

         int count = focusables.size();
         for (int i = 0; i < count; i++) {
             View view = focusables.get(i);
             int viewLeft = view.getLeft();
             int viewRight = view.getRight();

             if (left < viewRight && viewLeft < right) {
                 /*
                  * the focusable is in the target area, it is a candidate for
                  * focusing
                  */

                 final boolean viewIsFullyContained = (left < viewLeft) &&
                 (viewRight < right);

                 if (focusCandidate == null) {
                     /* No candidate, take this one */
                     focusCandidate = view;
                     foundFullyContainedFocusable = viewIsFullyContained;
                 } else {
                     final boolean viewIsCloserToBoundary =
                         (leftFocus && viewLeft < focusCandidate.getLeft()) ||
                         (!leftFocus && viewRight > focusCandidate.getRight());

                     if (foundFullyContainedFocusable) {
                         if (viewIsFullyContained && viewIsCloserToBoundary) {
                             /*
                              * We're dealing with only fully contained views, so
                              * it has to be closer to the boundary to beat our
                              * candidate
                              */
                             focusCandidate = view;
                         }
                     } else {
                         if (viewIsFullyContained) {
                             /* Any fully contained view beats a partially contained view */
                             focusCandidate = view;
                             foundFullyContainedFocusable = true;
                         } else if (viewIsCloserToBoundary) {
                             /*
                              * Partially contained view beats another partially
                              * contained view if it's closer
                              */
                             focusCandidate = view;
                         }
                     }
                 }
             }
         }

         return focusCandidate;
     }

     /**
      * <p>Handles scrolling in response to a "home/end" shortcut press. This
      * method will scroll the view to the top or bottom and give the focus
      * to the topmost/bottommost component in the new visible area. If no
      * component is a good candidate for focus, this scrollview reclaims the
      * focus.</p>
      *
      * @param direction the scroll direction: {@link android.view.View#FOCUS_UP}
      *                  to go the top of the view or
      *                  {@link android.view.View#FOCUS_DOWN} to go the bottom
      * @return true if the key event is consumed by this method, false otherwise
      */
     public boolean fullScrollV(int direction) {
         boolean down = direction == View.FOCUS_DOWN;
         int height = getHeight();

         mTempRect.top = 0;
         mTempRect.bottom = height;

         if (down) {
             int count = getChildCount();
             if (count > 0) {
                 View view = getChildAt(count - 1);
                 mTempRect.bottom = view.getBottom();
                 mTempRect.top = mTempRect.bottom - height;
             }
         }

         return scrollAndFocusV(direction, mTempRect.top, mTempRect.bottom);
     }

     public boolean fullScrollH(int direction) {
         boolean right = direction == View.FOCUS_RIGHT;
         int width = getWidth();

         mTempRect.left = 0;
         mTempRect.right = width;

         if (right) {
             int count = getChildCount();
             if (count > 0) {
                 View view = getChildAt(0);
                 mTempRect.right = view.getRight();
                 mTempRect.left = mTempRect.right - width;
             }
         }

         return scrollAndFocusH(direction, mTempRect.left, mTempRect.right);
     }

     /**
      * <p>Scrolls the view to make the area defined by <code>top</code> and
      * <code>bottom</code> visible. This method attempts to give the focus
      * to a component visible in this area. If no component can be focused in
      * the new visible area, the focus is reclaimed by this scrollview.</p>
      *
      * @param direction the scroll direction: {@link android.view.View#FOCUS_UP}
      *                  to go upward
      *                  {@link android.view.View#FOCUS_DOWN} to downward
      * @param top       the top offset of the new area to be made visible
      * @param bottom    the bottom offset of the new area to be made visible
      * @return true if the key event is consumed by this method, false otherwise
      */
     private boolean scrollAndFocusV(int direction, int top, int bottom) {
         boolean handled = true;

         int height = getHeight();
         int containerTop = getScrollY();
         int containerBottom = containerTop + height;
         boolean up = direction == View.FOCUS_UP;

         View newFocused = findFocusableViewInBoundsV(up, top, bottom);
         if (newFocused == null) {
             newFocused = this;
         }

         if (top >= containerTop && bottom <= containerBottom) {
             handled = false;
         } else {
             int delta = up ? (top - containerTop) : (bottom - containerBottom);
             doScrollY(delta);
         }

         if (newFocused != findFocus() && newFocused.requestFocus(direction)) {
             mScrollViewMovedFocus = true;
             mScrollViewMovedFocus = false;
         }

         return handled;
     }

     private boolean scrollAndFocusH(int direction, int left, int right) {
         boolean handled = true;

         int width = getWidth();
         int containerLeft = getScrollX();
         int containerRight = containerLeft + width;
         boolean goLeft = direction == View.FOCUS_LEFT;

         View newFocused = findFocusableViewInBoundsH(goLeft, left, right);
         if (newFocused == null) {
             newFocused = this;
         }

         if (left >= containerLeft && right <= containerRight) {
             handled = false;
         } else {
             int delta = goLeft ? (left - containerLeft) : (right - containerRight);
             doScrollX(delta);
         }

         if (newFocused != findFocus() && newFocused.requestFocus(direction)) {
             mScrollViewMovedFocus = true;
             mScrollViewMovedFocus = false;
         }

         return handled;
     }

     /**
      * Handle scrolling in response to an up or down arrow click.
      *
      * @param direction The direction corresponding to the arrow key that was
      *                  pressed
      * @return True if we consumed the event, false otherwise
      */
     public boolean arrowScrollV(int direction) {

         View currentFocused = findFocus();
         if (currentFocused == this) currentFocused = null;

         View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);

         final int maxJump = getMaxScrollAmountV();

         if (nextFocused != null && isWithinDeltaOfScreenV(nextFocused, maxJump, getHeight())) {
             nextFocused.getDrawingRect(mTempRect);
             offsetDescendantRectToMyCoords(nextFocused, mTempRect);
             int scrollDelta = computeScrollDeltaToGetChildRectOnScreenV(mTempRect);
             doScrollY(scrollDelta);
             nextFocused.requestFocus(direction);
         } else {
             // no new focus
             int scrollDelta = maxJump;

             if (direction == View.FOCUS_UP && getScrollY() < scrollDelta) {
                 scrollDelta = getScrollY();
             } else if (direction == View.FOCUS_DOWN) {
                 if (getChildCount() > 0) {
                     int daBottom = getChildAt(0).getBottom();

                     int screenBottom = getScrollY() + getHeight();

                     if (daBottom - screenBottom < maxJump) {
                         scrollDelta = daBottom - screenBottom;
                     }
                 }
             }
             if (scrollDelta == 0) {
                 return false;
             }
             doScrollY(direction == View.FOCUS_DOWN ? scrollDelta : -scrollDelta);
         }

         if (currentFocused != null && currentFocused.isFocused()
                 && isOffScreenV(currentFocused)) {
             // previously focused item still has focus and is off screen, give
             // it up (take it back to ourselves)
             // (also, need to temporarily force FOCUS_BEFORE_DESCENDANTS so we are
             // sure to
             // get it)
             final int descendantFocusability = getDescendantFocusability();  // save
             setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS);
             requestFocus();
             setDescendantFocusability(descendantFocusability);  // restore
         }
         return true;
     }

     public boolean arrowScrollH(int direction) {

         View currentFocused = findFocus();
         if (currentFocused == this) currentFocused = null;

         View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);

         final int maxJump = getMaxScrollAmountH();

         if (nextFocused != null && isWithinDeltaOfScreenH(nextFocused, maxJump)) {
             nextFocused.getDrawingRect(mTempRect);
             offsetDescendantRectToMyCoords(nextFocused, mTempRect);
             int scrollDelta = computeScrollDeltaToGetChildRectOnScreenH(mTempRect);
             doScrollX(scrollDelta);
             nextFocused.requestFocus(direction);
         } else {
             // no new focus
             int scrollDelta = maxJump;

             if (direction == View.FOCUS_LEFT && getScrollX() < scrollDelta) {
                 scrollDelta = getScrollX();
             } else if (direction == View.FOCUS_RIGHT && getChildCount() > 0) {

                 int daRight = getChildAt(0).getRight();

                 int screenRight = getScrollX() + getWidth();

                 if (daRight - screenRight < maxJump) {
                     scrollDelta = daRight - screenRight;
                 }
             }
             if (scrollDelta == 0) {
                 return false;
             }
             doScrollX(direction == View.FOCUS_RIGHT ? scrollDelta : -scrollDelta);
         }

         if (currentFocused != null && currentFocused.isFocused()
                 && isOffScreenH(currentFocused)) {
             // previously focused item still has focus and is off screen, give
             // it up (take it back to ourselves)
             // (also, need to temporarily force FOCUS_BEFORE_DESCENDANTS so we are
             // sure to
             // get it)
             final int descendantFocusability = getDescendantFocusability();  // save
             setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS);
             requestFocus();
             setDescendantFocusability(descendantFocusability);  // restore
         }
         return true;
     }
     /**
      * @return whether the descendant of this scroll view is scrolled off
      *  screen.
      */
     private boolean isOffScreenV(View descendant) {
         return !isWithinDeltaOfScreenV(descendant, 0, getHeight());
     }

     private boolean isOffScreenH(View descendant) {
         return !isWithinDeltaOfScreenH(descendant, 0);
     }

     /**
      * @return whether the descendant of this scroll view is within delta
      *  pixels of being on the screen.
      */
     private boolean isWithinDeltaOfScreenV(View descendant, int delta, int height) {
         descendant.getDrawingRect(mTempRect);
         offsetDescendantRectToMyCoords(descendant, mTempRect);

         return (mTempRect.bottom + delta) >= getScrollY()
         && (mTempRect.top - delta) <= (getScrollY() + height);
     }

     private boolean isWithinDeltaOfScreenH(View descendant, int delta) {
         descendant.getDrawingRect(mTempRect);
         offsetDescendantRectToMyCoords(descendant, mTempRect);

         return (mTempRect.right + delta) >= getScrollX()
         && (mTempRect.left - delta) <= (getScrollX() + getWidth());
     }

     /**
      * Smooth scroll by a Y delta
      *
      * @param delta the number of pixels to scroll by on the Y axis
      */
     private void doScrollY(int delta) {
         if (delta != 0) {
             if (mSmoothScrollingEnabled) {
                 smoothScrollBy(0, delta);
             } else {
                 scrollBy(0, delta);
             }
         }
     }

     private void doScrollX(int delta) {
         if (delta != 0) {
             if (mSmoothScrollingEnabled) {
                 smoothScrollBy(delta, 0);
             } else {
                 scrollBy(delta, 0);
             }
         }
     }

     /**
      * Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
      *
      * @param dx the number of pixels to scroll by on the X axis
      * @param dy the number of pixels to scroll by on the Y axis
      */
     public void smoothScrollBy(int dx, int dy) {
         if (getChildCount() == 0) {
             // Nothing to do.
             return;
         }
         long duration = AnimationUtils.currentAnimationTimeMillis() - mLastScroll;
         if (duration > ANIMATED_SCROLL_GAP) {
             final int height = getHeight() - getPaddingBottom() - getPaddingTop();
             final int bottom = getChildAt(0).getHeight();
             final int maxY = Math.max(0, bottom - height);
             final int scrollY = getScrollY();
             dy = Math.max(0, Math.min(scrollY + dy, maxY)) - scrollY;

             final int width = getWidth() - getPaddingRight() - getPaddingLeft();
             final int right = getChildAt(0).getWidth();
             final int maxX = Math.max(0, right - width);
             final int scrollX = getScrollX();
             dx = Math.max(0, Math.min(scrollX + dx, maxX)) - scrollX;

             mScroller.startScroll(scrollX, scrollY, dx, dy);
             invalidate();
         } else {
             if (!mScroller.isFinished()) {
                 mScroller.abortAnimation();
             }
             scrollBy(dx, dy);
         }
         mLastScroll = AnimationUtils.currentAnimationTimeMillis();
     }

     /**
      * Like {@link #scrollTo}, but scroll smoothly instead of immediately.
      *
      * @param x the position where to scroll on the X axis
      * @param y the position where to scroll on the Y axis
      */
     public final void smoothScrollTo(int x, int y) {
         smoothScrollBy(x - getScrollX(), y - getScrollY());
     }

     /**
      * <p>The scroll range of a scroll view is the overall height of all of its
      * children.</p>
      */
     @Override
     protected int computeVerticalScrollRange() {
         final int count = getChildCount();
         final int contentHeight = getHeight() - getPaddingBottom() - getPaddingTop();
         if (count == 0) {
             return contentHeight;
         }

         return getChildAt(0).getBottom();
     }

     @Override
     protected int computeHorizontalScrollRange() {
         final int count = getChildCount();
         final int contentWidth = getWidth() - getPaddingLeft() - getPaddingRight();
         if (count == 0) {
             return contentWidth;
         }

         return getChildAt(0).getRight();
     }

     @Override
     protected int computeVerticalScrollOffset() {
         return Math.max(0, super.computeVerticalScrollOffset());
     }

     @Override
     protected int computeHorizontalScrollOffset() {
         return Math.max(0, super.computeHorizontalScrollOffset());
     }

     @Override
     protected void measureChild(View child, int parentWidthMeasureSpec, int parentHeightMeasureSpec) {
         int childWidthMeasureSpec;
         int childHeightMeasureSpec;

         childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);

         childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);

         child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
     }

     @Override
     protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed,
                                            int parentHeightMeasureSpec, int heightUsed) {
         final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

         final int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
                 lp.leftMargin + lp.rightMargin, MeasureSpec.UNSPECIFIED);
         final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                 lp.topMargin + lp.bottomMargin, MeasureSpec.UNSPECIFIED);

         child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
     }

     @Override
     public void computeScroll() {
         if (mScroller.computeScrollOffset()) {
             // This is called at drawing time by ViewGroup.  We don't want to
             // re-show the scrollbars at this point, which scrollTo will do,
             // so we replicate most of scrollTo here.
             //
             //         It's a little odd to call onScrollChanged from inside the drawing.
             //
             //         It is, except when you remember that computeScroll() is used to
             //         animate scrolling. So unless we want to defer the onScrollChanged()
             //         until the end of the animated scrolling, we don't really have a
             //         choice here.
             //
             //         I agree.  The alternative, which I think would be worse, is to post
             //         something and tell the subclasses later.  This is bad because there
             //         will be a window where mScrollX/Y is different from what the app
             //         thinks it is.
             //
             int x = mScroller.getCurrX();
             int y = mScroller.getCurrY();

             if (getChildCount() > 0) {
                 View child = getChildAt(0);
                 x = clamp(x, getWidth() - getPaddingRight() - getPaddingLeft(), child.getWidth());
                 y = clamp(y, getHeight() - getPaddingBottom() - getPaddingTop(), child.getHeight());
                 super.scrollTo(x, y);
             }
             awakenScrollBars();

             // Keep on drawing until the animation has finished.
             postInvalidate();
         }
     }

     /**
      * Scrolls the view to the given child.
      *
      * @param child the View to scroll to
      */
     private void scrollToChild(View child) {
         child.getDrawingRect(mTempRect);

         /* Offset from child's local coordinates to ScrollView coordinates */
         offsetDescendantRectToMyCoords(child, mTempRect);

         int scrollDeltaV = computeScrollDeltaToGetChildRectOnScreenV(mTempRect);
         int scrollDeltaH = computeScrollDeltaToGetChildRectOnScreenH(mTempRect);

         if (scrollDeltaH != 0 || scrollDeltaV != 0) {
             scrollBy(scrollDeltaH, scrollDeltaV);
         }
     }

     /**
      * If rect is off screen, scroll just enough to get it (or at least the
      * first screen size chunk of it) on screen.
      *
      * @param rect      The rectangle.
      * @param immediate True to scroll immediately without animation
      * @return true if scrolling was performed
      */
     private boolean scrollToChildRect(Rect rect, boolean immediate) {
         final int deltaV = computeScrollDeltaToGetChildRectOnScreenV(rect);
         final int deltaH = computeScrollDeltaToGetChildRectOnScreenH(rect);
         final boolean scroll = deltaH != 0 || deltaV != 0;
         if (scroll) {
             if (immediate) {
                 scrollBy(deltaH, deltaV);
             } else {
                 smoothScrollBy(deltaH, deltaV);
             }
         }
         return scroll;
     }
     /**
      * Compute the amount to scroll in the Y direction in order to get
      * a rectangle completely on the screen (or, if taller than the screen,
      * at least the first screen size chunk of it).
      *
      * @param rect The rect.
      * @return The scroll delta.
      */
     protected int computeScrollDeltaToGetChildRectOnScreenV(Rect rect) {
         if (getChildCount() == 0) return 0;

         int height = getHeight();
         int screenTop = getScrollY();
         int screenBottom = screenTop + height;

         int fadingEdge = getVerticalFadingEdgeLength();

         // leave room for top fading edge as long as rect isn't at very top
         if (rect.top > 0) {
             screenTop += fadingEdge;
         }

         // leave room for bottom fading edge as long as rect isn't at very bottom
         if (rect.bottom < getChildAt(0).getHeight()) {
             screenBottom -= fadingEdge;
         }

         int scrollYDelta = 0;

         if (rect.bottom > screenBottom && rect.top > screenTop) {
             // need to move down to get it in view: move down just enough so
             // that the entire rectangle is in view (or at least the first
             // screen size chunk).

             if (rect.height() > height) {
                 // just enough to get screen size chunk on
                 scrollYDelta += (rect.top - screenTop);
             } else {
                 // get entire rect at bottom of screen
                 scrollYDelta += (rect.bottom - screenBottom);
             }

             // make sure we aren't scrolling beyond the end of our content
             int bottom = getChildAt(0).getBottom();
             int distanceToBottom = bottom - screenBottom;
             scrollYDelta = Math.min(scrollYDelta, distanceToBottom);

         } else if (rect.top < screenTop && rect.bottom < screenBottom) {
             // need to move up to get it in view: move up just enough so that
             // entire rectangle is in view (or at least the first screen
             // size chunk of it).

             if (rect.height() > height) {
                 // screen size chunk
                 scrollYDelta -= (screenBottom - rect.bottom);
             } else {
                 // entire rect at top
                 scrollYDelta -= (screenTop - rect.top);
             }

             // make sure we aren't scrolling any further than the top our content
             scrollYDelta = Math.max(scrollYDelta, -getScrollY());
         }
         return scrollYDelta;
     }

     protected int computeScrollDeltaToGetChildRectOnScreenH(Rect rect) {
         if (getChildCount() == 0) return 0;

         int width = getWidth();
         int screenLeft = getScrollX();
         int screenRight = screenLeft + width;

         int fadingEdge = getHorizontalFadingEdgeLength();

         // leave room for left fading edge as long as rect isn't at very left
         if (rect.left > 0) {
             screenLeft += fadingEdge;
         }

         // leave room for right fading edge as long as rect isn't at very right
         if (rect.right < getChildAt(0).getWidth()) {
             screenRight -= fadingEdge;
         }

         int scrollXDelta = 0;

         if (rect.right > screenRight && rect.left > screenLeft) {
             // need to move right to get it in view: move right just enough so
             // that the entire rectangle is in view (or at least the first
             // screen size chunk).

             if (rect.width() > width) {
                 // just enough to get screen size chunk on
                 scrollXDelta += (rect.left - screenLeft);
             } else {
                 // get entire rect at right of screen
                 scrollXDelta += (rect.right - screenRight);
             }

             // make sure we aren't scrolling beyond the end of our content
             int right = getChildAt(0).getRight();
             int distanceToRight = right - screenRight;
             scrollXDelta = Math.min(scrollXDelta, distanceToRight);

         } else if (rect.left < screenLeft && rect.right < screenRight) {
             // need to move right to get it in view: move right just enough so that
             // entire rectangle is in view (or at least the first screen
             // size chunk of it).

             if (rect.width() > width) {
                 // screen size chunk
                 scrollXDelta -= (screenRight - rect.right);
             } else {
                 // entire rect at left
                 scrollXDelta -= (screenLeft - rect.left);
             }

             // make sure we aren't scrolling any further than the left our content
             scrollXDelta = Math.max(scrollXDelta, -getScrollX());
         }
         return scrollXDelta;
     }

     @Override
     public void requestChildFocus(View child, View focused) {
         if (!mScrollViewMovedFocus) {
             if (!mIsLayoutDirty) {
                 scrollToChild(focused);
             } else {
                 // The child may not be laid out yet, we can't compute the scroll yet
                 mChildToScrollTo = focused;
             }
         }
         super.requestChildFocus(child, focused);
     }


     /**
      * When looking for focus in children of a scroll view, need to be a little
      * more careful not to give focus to something that is scrolled off screen.
      *
      * This is more expensive than the default {@link android.view.ViewGroup}
      * implementation, otherwise this behavior might have been made the default.
      */
     @Override
     protected boolean onRequestFocusInDescendants(int direction,
             Rect previouslyFocusedRect) {

         // convert from forward / backward notation to up / down / left / right
         // (ugh).
         // TODO: FUCK
         //        if (direction == View.FOCUS_FORWARD) {
         //            direction = View.FOCUS_RIGHT;
         //        } else if (direction == View.FOCUS_BACKWARD) {
         //            direction = View.FOCUS_LEFT;
         //        }

         final View nextFocus = previouslyFocusedRect == null ?
                 FocusFinder.getInstance().findNextFocus(this, null, direction) :
                     FocusFinder.getInstance().findNextFocusFromRect(this,
                             previouslyFocusedRect, direction);

                 if (nextFocus == null) {
                     return false;
                 }

                 //        if (isOffScreenH(nextFocus)) {
                     //            return false;
                 //        }

                 return nextFocus.requestFocus(direction, previouslyFocusedRect);
     }

     @Override
     public boolean requestChildRectangleOnScreen(View child, Rect rectangle,
                                                  boolean immediate) {
         // offset into coordinate space of this scroll view
         rectangle.offset(child.getLeft() - child.getScrollX(),
                 child.getTop() - child.getScrollY());

         return scrollToChildRect(rectangle, immediate);
     }

     @Override
     public void requestLayout() {
         mIsLayoutDirty = true;
         super.requestLayout();
     }

     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         super.onLayout(changed, l, t, r, b);
         mIsLayoutDirty = false;
         // Give a child focus if it needs it
         if (mChildToScrollTo != null && isViewDescendantOf(mChildToScrollTo, this)) {
             scrollToChild(mChildToScrollTo);
         }
         mChildToScrollTo = null;

         // Calling this with the present values causes it to re-clam them
         scrollTo(getScrollX(), getScrollY());
     }

     @Override
     protected void onSizeChanged(int w, int h, int oldw, int oldh) {
         super.onSizeChanged(w, h, oldw, oldh);

         View currentFocused = findFocus();
         if (null == currentFocused || this == currentFocused)
             return;

         // If the currently-focused view was visible on the screen when the
         // screen was at the old height, then scroll the screen to make that
         // view visible with the new screen height.
         if (isWithinDeltaOfScreenV(currentFocused, 0, oldh)) {
             currentFocused.getDrawingRect(mTempRect);
             offsetDescendantRectToMyCoords(currentFocused, mTempRect);
             int scrollDelta = computeScrollDeltaToGetChildRectOnScreenV(mTempRect);
             doScrollY(scrollDelta);
         }

         final int maxJump = getRight() - getLeft();
         if (isWithinDeltaOfScreenH(currentFocused, maxJump)) {
             currentFocused.getDrawingRect(mTempRect);
             offsetDescendantRectToMyCoords(currentFocused, mTempRect);
             int scrollDelta = computeScrollDeltaToGetChildRectOnScreenH(mTempRect);
             doScrollX(scrollDelta);
         }
     }

     /**
      * Return true if child is an descendant of parent, (or equal to the parent).
      */
     private boolean isViewDescendantOf(View child, View parent) {
         if (child == parent) {
             return true;
         }

         final ViewParent theParent = child.getParent();
         return (theParent instanceof ViewGroup) && isViewDescendantOf((View) theParent, parent);
     }

     /**
      * Fling the scroll view
      *
      * @param velocityY The initial velocity in the Y direction. Positive
      *                  numbers mean that the finger/cursor is moving down the screen,
      *                  which means we want to scroll towards the top.
      */
     public void fling(int velocityX, int velocityY) {
         if (getChildCount() > 0) {
             int width = getWidth() - getPaddingRight() - getPaddingLeft();
             int right = getChildAt(0).getWidth();

             int height = getHeight() - getPaddingBottom() - getPaddingTop();
             int bottom = getChildAt(0).getHeight();

             mScroller.fling(getScrollX(), getScrollY(), velocityX, velocityY,
                     0, Math.max(0, right - width),
                     0, Math.max(0, bottom - height));

             //            final boolean movingDown = velocityX > 0 || velocityY > 0;
             //
             //            View newFocused =
             //                    findFocusableViewInMyBoundsV(movingDown, mScroller.getFinalY(), findFocus());
             //            if (newFocused == null) {
             //                newFocused = this;
             //            }
             //
             //            if (newFocused != findFocus()
             //                    && newFocused.requestFocus(movingDown ? View.FOCUS_DOWN : View.FOCUS_UP)) {
             //                mScrollViewMovedFocus = true;
             //                mScrollViewMovedFocus = false;
             //            }

             invalidate();
         }
     }

     /**
      * {@inheritDoc}
      *
      * <p>This version also clamps the scrolling to the bounds of our child.
      */
     @Override
     public void scrollTo(int x, int y) {
         // we rely on the fact the View.scrollBy calls scrollTo.
         if (getChildCount() > 0) {
             View child = getChildAt(0);
             x = clamp(x, getWidth() - getPaddingRight() - getPaddingLeft(), child.getWidth());
             y = clamp(y, getHeight() - getPaddingBottom() - getPaddingTop(), child.getHeight());
             if (x != getScrollX() || y != getScrollY()) {
                 super.scrollTo(x, y);
             }
         }
     }

     private int clamp(int n, int my, int child) {
         if (my >= child || n < 0) {
             /* my >= child is this case:
              *                    |--------------- me ---------------|
              *     |------ child ------|
              * or
              *     |--------------- me ---------------|
              *            |------ child ------|
              * or
              *     |--------------- me ---------------|
              *                                  |------ child ------|
              *
              * n < 0 is this case:
              *     |------ me ------|
              *                    |-------- child --------|
              *     |-- mScrollX --|
              */
             return 0;
         }
         if ((my+n) > child) {
             /* this case:
              *                    |------ me ------|
              *     |------ child ------|
              *     |-- mScrollX --|
              */
             return child-my;
         }
         return n;
     }

     public boolean isFlingEnabled() {
         return mFlingEnabled;
     }

     public void setFlingEnabled(boolean flingEnabled) {
         this.mFlingEnabled = flingEnabled;
     }
 }